home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / rdma / ib_mad.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  22.3 KB  |  656 lines
  1. /*
  2.  * Copyright (c) 2004 Mellanox Technologies Ltd.  All rights reserved.
  3.  * Copyright (c) 2004 Infinicon Corporation.  All rights reserved.
  4.  * Copyright (c) 2004 Intel Corporation.  All rights reserved.
  5.  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
  6.  * Copyright (c) 2004-2006 Voltaire Corporation.  All rights reserved.
  7.  *
  8.  * This software is available to you under a choice of one of two
  9.  * licenses.  You may choose to be licensed under the terms of the GNU
  10.  * General Public License (GPL) Version 2, available from the file
  11.  * COPYING in the main directory of this source tree, or the
  12.  * OpenIB.org BSD license below:
  13.  *
  14.  *     Redistribution and use in source and binary forms, with or
  15.  *     without modification, are permitted provided that the following
  16.  *     conditions are met:
  17.  *
  18.  *      - Redistributions of source code must retain the above
  19.  *        copyright notice, this list of conditions and the following
  20.  *        disclaimer.
  21.  *
  22.  *      - Redistributions in binary form must reproduce the above
  23.  *        copyright notice, this list of conditions and the following
  24.  *        disclaimer in the documentation and/or other materials
  25.  *        provided with the distribution.
  26.  *
  27.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  28.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  29.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  30.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  31.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  32.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  33.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  34.  * SOFTWARE.
  35.  */
  36.  
  37. #if !defined(IB_MAD_H)
  38. #define IB_MAD_H
  39.  
  40. #include <linux/list.h>
  41.  
  42. #include <rdma/ib_verbs.h>
  43.  
  44. /* Management base version */
  45. #define IB_MGMT_BASE_VERSION            1
  46.  
  47. /* Management classes */
  48. #define IB_MGMT_CLASS_SUBN_LID_ROUTED        0x01
  49. #define IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE    0x81
  50. #define IB_MGMT_CLASS_SUBN_ADM            0x03
  51. #define IB_MGMT_CLASS_PERF_MGMT            0x04
  52. #define IB_MGMT_CLASS_BM            0x05
  53. #define IB_MGMT_CLASS_DEVICE_MGMT        0x06
  54. #define IB_MGMT_CLASS_CM            0x07
  55. #define IB_MGMT_CLASS_SNMP            0x08
  56. #define IB_MGMT_CLASS_DEVICE_ADM        0x10
  57. #define IB_MGMT_CLASS_BOOT_MGMT            0x11
  58. #define IB_MGMT_CLASS_BIS            0x12
  59. #define IB_MGMT_CLASS_CONG_MGMT            0x21
  60. #define IB_MGMT_CLASS_VENDOR_RANGE2_START    0x30
  61. #define IB_MGMT_CLASS_VENDOR_RANGE2_END        0x4F
  62.  
  63. #define    IB_OPENIB_OUI                (0x001405)
  64.  
  65. /* Management methods */
  66. #define IB_MGMT_METHOD_GET            0x01
  67. #define IB_MGMT_METHOD_SET            0x02
  68. #define IB_MGMT_METHOD_GET_RESP            0x81
  69. #define IB_MGMT_METHOD_SEND            0x03
  70. #define IB_MGMT_METHOD_TRAP            0x05
  71. #define IB_MGMT_METHOD_REPORT            0x06
  72. #define IB_MGMT_METHOD_REPORT_RESP        0x86
  73. #define IB_MGMT_METHOD_TRAP_REPRESS        0x07
  74.  
  75. #define IB_MGMT_METHOD_RESP            0x80
  76. #define IB_BM_ATTR_MOD_RESP            cpu_to_be32(1)
  77.  
  78. #define IB_MGMT_MAX_METHODS            128
  79.  
  80. /* RMPP information */
  81. #define IB_MGMT_RMPP_VERSION            1
  82.  
  83. #define IB_MGMT_RMPP_TYPE_DATA            1
  84. #define IB_MGMT_RMPP_TYPE_ACK            2
  85. #define IB_MGMT_RMPP_TYPE_STOP            3
  86. #define IB_MGMT_RMPP_TYPE_ABORT            4
  87.  
  88. #define IB_MGMT_RMPP_FLAG_ACTIVE        1
  89. #define IB_MGMT_RMPP_FLAG_FIRST            (1<<1)
  90. #define IB_MGMT_RMPP_FLAG_LAST            (1<<2)
  91.  
  92. #define IB_MGMT_RMPP_NO_RESPTIME        0x1F
  93.  
  94. #define    IB_MGMT_RMPP_STATUS_SUCCESS        0
  95. #define    IB_MGMT_RMPP_STATUS_RESX        1
  96. #define    IB_MGMT_RMPP_STATUS_ABORT_MIN        118
  97. #define    IB_MGMT_RMPP_STATUS_T2L            118
  98. #define    IB_MGMT_RMPP_STATUS_BAD_LEN        119
  99. #define    IB_MGMT_RMPP_STATUS_BAD_SEG        120
  100. #define    IB_MGMT_RMPP_STATUS_BADT        121
  101. #define    IB_MGMT_RMPP_STATUS_W2S            122
  102. #define    IB_MGMT_RMPP_STATUS_S2B            123
  103. #define    IB_MGMT_RMPP_STATUS_BAD_STATUS        124
  104. #define    IB_MGMT_RMPP_STATUS_UNV            125
  105. #define    IB_MGMT_RMPP_STATUS_TMR            126
  106. #define    IB_MGMT_RMPP_STATUS_UNSPEC        127
  107. #define    IB_MGMT_RMPP_STATUS_ABORT_MAX        127
  108.  
  109. #define IB_QP0        0
  110. #define IB_QP1        __constant_htonl(1)
  111. #define IB_QP1_QKEY    0x80010000
  112. #define IB_QP_SET_QKEY    0x80000000
  113.  
  114. #define IB_DEFAULT_PKEY_PARTIAL 0x7FFF
  115. #define IB_DEFAULT_PKEY_FULL    0xFFFF
  116.  
  117. enum {
  118.     IB_MGMT_MAD_HDR = 24,
  119.     IB_MGMT_MAD_DATA = 232,
  120.     IB_MGMT_RMPP_HDR = 36,
  121.     IB_MGMT_RMPP_DATA = 220,
  122.     IB_MGMT_VENDOR_HDR = 40,
  123.     IB_MGMT_VENDOR_DATA = 216,
  124.     IB_MGMT_SA_HDR = 56,
  125.     IB_MGMT_SA_DATA = 200,
  126.     IB_MGMT_DEVICE_HDR = 64,
  127.     IB_MGMT_DEVICE_DATA = 192,
  128. };
  129.  
  130. struct ib_mad_hdr {
  131.     u8    base_version;
  132.     u8    mgmt_class;
  133.     u8    class_version;
  134.     u8    method;
  135.     __be16    status;
  136.     __be16    class_specific;
  137.     __be64    tid;
  138.     __be16    attr_id;
  139.     __be16    resv;
  140.     __be32    attr_mod;
  141. };
  142.  
  143. struct ib_rmpp_hdr {
  144.     u8    rmpp_version;
  145.     u8    rmpp_type;
  146.     u8    rmpp_rtime_flags;
  147.     u8    rmpp_status;
  148.     __be32    seg_num;
  149.     __be32    paylen_newwin;
  150. };
  151.  
  152. typedef u64 __bitwise ib_sa_comp_mask;
  153.  
  154. #define IB_SA_COMP_MASK(n) ((__force ib_sa_comp_mask) cpu_to_be64(1ull << n))
  155.  
  156. /*
  157.  * ib_sa_hdr and ib_sa_mad structures must be packed because they have
  158.  * 64-bit fields that are only 32-bit aligned. 64-bit architectures will
  159.  * lay them out wrong otherwise.  (And unfortunately they are sent on
  160.  * the wire so we can't change the layout)
  161.  */
  162. struct ib_sa_hdr {
  163.     __be64            sm_key;
  164.     __be16            attr_offset;
  165.     __be16            reserved;
  166.     ib_sa_comp_mask        comp_mask;
  167. } __attribute__ ((packed));
  168.  
  169. struct ib_mad {
  170.     struct ib_mad_hdr    mad_hdr;
  171.     u8            data[IB_MGMT_MAD_DATA];
  172. };
  173.  
  174. struct ib_rmpp_mad {
  175.     struct ib_mad_hdr    mad_hdr;
  176.     struct ib_rmpp_hdr    rmpp_hdr;
  177.     u8            data[IB_MGMT_RMPP_DATA];
  178. };
  179.  
  180. struct ib_sa_mad {
  181.     struct ib_mad_hdr    mad_hdr;
  182.     struct ib_rmpp_hdr    rmpp_hdr;
  183.     struct ib_sa_hdr    sa_hdr;
  184.     u8            data[IB_MGMT_SA_DATA];
  185. } __attribute__ ((packed));
  186.  
  187. struct ib_vendor_mad {
  188.     struct ib_mad_hdr    mad_hdr;
  189.     struct ib_rmpp_hdr    rmpp_hdr;
  190.     u8            reserved;
  191.     u8            oui[3];
  192.     u8            data[IB_MGMT_VENDOR_DATA];
  193. };
  194.  
  195. struct ib_class_port_info {
  196.     u8            base_version;
  197.     u8            class_version;
  198.     __be16            capability_mask;
  199.     u8            reserved[3];
  200.     u8            resp_time_value;
  201.     u8            redirect_gid[16];
  202.     __be32            redirect_tcslfl;
  203.     __be16            redirect_lid;
  204.     __be16            redirect_pkey;
  205.     __be32            redirect_qp;
  206.     __be32            redirect_qkey;
  207.     u8            trap_gid[16];
  208.     __be32            trap_tcslfl;
  209.     __be16            trap_lid;
  210.     __be16            trap_pkey;
  211.     __be32            trap_hlqp;
  212.     __be32            trap_qkey;
  213. };
  214.  
  215. /**
  216.  * ib_mad_send_buf - MAD data buffer and work request for sends.
  217.  * @next: A pointer used to chain together MADs for posting.
  218.  * @mad: References an allocated MAD data buffer for MADs that do not have
  219.  *   RMPP active.  For MADs using RMPP, references the common and management
  220.  *   class specific headers.
  221.  * @mad_agent: MAD agent that allocated the buffer.
  222.  * @ah: The address handle to use when sending the MAD.
  223.  * @context: User-controlled context fields.
  224.  * @hdr_len: Indicates the size of the data header of the MAD.  This length
  225.  *   includes the common MAD, RMPP, and class specific headers.
  226.  * @data_len: Indicates the total size of user-transferred data.
  227.  * @seg_count: The number of RMPP segments allocated for this send.
  228.  * @seg_size: Size of each RMPP segment.
  229.  * @timeout_ms: Time to wait for a response.
  230.  * @retries: Number of times to retry a request for a response.  For MADs
  231.  *   using RMPP, this applies per window.  On completion, returns the number
  232.  *   of retries needed to complete the transfer.
  233.  *
  234.  * Users are responsible for initializing the MAD buffer itself, with the
  235.  * exception of any RMPP header.  Additional segment buffer space allocated
  236.  * beyond data_len is padding.
  237.  */
  238. struct ib_mad_send_buf {
  239.     struct ib_mad_send_buf    *next;
  240.     void            *mad;
  241.     struct ib_mad_agent    *mad_agent;
  242.     struct ib_ah        *ah;
  243.     void            *context[2];
  244.     int            hdr_len;
  245.     int            data_len;
  246.     int            seg_count;
  247.     int            seg_size;
  248.     int            timeout_ms;
  249.     int            retries;
  250. };
  251.  
  252. /**
  253.  * ib_response_mad - Returns if the specified MAD has been generated in
  254.  *   response to a sent request or trap.
  255.  */
  256. int ib_response_mad(struct ib_mad *mad);
  257.  
  258. /**
  259.  * ib_get_rmpp_resptime - Returns the RMPP response time.
  260.  * @rmpp_hdr: An RMPP header.
  261.  */
  262. static inline u8 ib_get_rmpp_resptime(struct ib_rmpp_hdr *rmpp_hdr)
  263. {
  264.     return rmpp_hdr->rmpp_rtime_flags >> 3;
  265. }
  266.  
  267. /**
  268.  * ib_get_rmpp_flags - Returns the RMPP flags.
  269.  * @rmpp_hdr: An RMPP header.
  270.  */
  271. static inline u8 ib_get_rmpp_flags(struct ib_rmpp_hdr *rmpp_hdr)
  272. {
  273.     return rmpp_hdr->rmpp_rtime_flags & 0x7;
  274. }
  275.  
  276. /**
  277.  * ib_set_rmpp_resptime - Sets the response time in an RMPP header.
  278.  * @rmpp_hdr: An RMPP header.
  279.  * @rtime: The response time to set.
  280.  */
  281. static inline void ib_set_rmpp_resptime(struct ib_rmpp_hdr *rmpp_hdr, u8 rtime)
  282. {
  283.     rmpp_hdr->rmpp_rtime_flags = ib_get_rmpp_flags(rmpp_hdr) | (rtime << 3);
  284. }
  285.  
  286. /**
  287.  * ib_set_rmpp_flags - Sets the flags in an RMPP header.
  288.  * @rmpp_hdr: An RMPP header.
  289.  * @flags: The flags to set.
  290.  */
  291. static inline void ib_set_rmpp_flags(struct ib_rmpp_hdr *rmpp_hdr, u8 flags)
  292. {
  293.     rmpp_hdr->rmpp_rtime_flags = (rmpp_hdr->rmpp_rtime_flags & 0xF1) |
  294.                      (flags & 0x7);
  295. }
  296.  
  297. struct ib_mad_agent;
  298. struct ib_mad_send_wc;
  299. struct ib_mad_recv_wc;
  300.  
  301. /**
  302.  * ib_mad_send_handler - callback handler for a sent MAD.
  303.  * @mad_agent: MAD agent that sent the MAD.
  304.  * @mad_send_wc: Send work completion information on the sent MAD.
  305.  */
  306. typedef void (*ib_mad_send_handler)(struct ib_mad_agent *mad_agent,
  307.                     struct ib_mad_send_wc *mad_send_wc);
  308.  
  309. /**
  310.  * ib_mad_snoop_handler - Callback handler for snooping sent MADs.
  311.  * @mad_agent: MAD agent that snooped the MAD.
  312.  * @send_wr: Work request information on the sent MAD.
  313.  * @mad_send_wc: Work completion information on the sent MAD.  Valid
  314.  *   only for snooping that occurs on a send completion.
  315.  *
  316.  * Clients snooping MADs should not modify data referenced by the @send_wr
  317.  * or @mad_send_wc.
  318.  */
  319. typedef void (*ib_mad_snoop_handler)(struct ib_mad_agent *mad_agent,
  320.                      struct ib_mad_send_buf *send_buf,
  321.                      struct ib_mad_send_wc *mad_send_wc);
  322.  
  323. /**
  324.  * ib_mad_recv_handler - callback handler for a received MAD.
  325.  * @mad_agent: MAD agent requesting the received MAD.
  326.  * @mad_recv_wc: Received work completion information on the received MAD.
  327.  *
  328.  * MADs received in response to a send request operation will be handed to
  329.  * the user before the send operation completes.  All data buffers given
  330.  * to registered agents through this routine are owned by the receiving
  331.  * client, except for snooping agents.  Clients snooping MADs should not
  332.  * modify the data referenced by @mad_recv_wc.
  333.  */
  334. typedef void (*ib_mad_recv_handler)(struct ib_mad_agent *mad_agent,
  335.                     struct ib_mad_recv_wc *mad_recv_wc);
  336.  
  337. /**
  338.  * ib_mad_agent - Used to track MAD registration with the access layer.
  339.  * @device: Reference to device registration is on.
  340.  * @qp: Reference to QP used for sending and receiving MADs.
  341.  * @mr: Memory region for system memory usable for DMA.
  342.  * @recv_handler: Callback handler for a received MAD.
  343.  * @send_handler: Callback handler for a sent MAD.
  344.  * @snoop_handler: Callback handler for snooped sent MADs.
  345.  * @context: User-specified context associated with this registration.
  346.  * @hi_tid: Access layer assigned transaction ID for this client.
  347.  *   Unsolicited MADs sent by this client will have the upper 32-bits
  348.  *   of their TID set to this value.
  349.  * @port_num: Port number on which QP is registered
  350.  * @rmpp_version: If set, indicates the RMPP version used by this agent.
  351.  */
  352. struct ib_mad_agent {
  353.     struct ib_device    *device;
  354.     struct ib_qp        *qp;
  355.     struct ib_mr        *mr;
  356.     ib_mad_recv_handler    recv_handler;
  357.     ib_mad_send_handler    send_handler;
  358.     ib_mad_snoop_handler    snoop_handler;
  359.     void            *context;
  360.     u32            hi_tid;
  361.     u8            port_num;
  362.     u8            rmpp_version;
  363. };
  364.  
  365. /**
  366.  * ib_mad_send_wc - MAD send completion information.
  367.  * @send_buf: Send MAD data buffer associated with the send MAD request.
  368.  * @status: Completion status.
  369.  * @vendor_err: Optional vendor error information returned with a failed
  370.  *   request.
  371.  */
  372. struct ib_mad_send_wc {
  373.     struct ib_mad_send_buf    *send_buf;
  374.     enum ib_wc_status    status;
  375.     u32            vendor_err;
  376. };
  377.  
  378. /**
  379.  * ib_mad_recv_buf - received MAD buffer information.
  380.  * @list: Reference to next data buffer for a received RMPP MAD.
  381.  * @grh: References a data buffer containing the global route header.
  382.  *   The data refereced by this buffer is only valid if the GRH is
  383.  *   valid.
  384.  * @mad: References the start of the received MAD.
  385.  */
  386. struct ib_mad_recv_buf {
  387.     struct list_head    list;
  388.     struct ib_grh        *grh;
  389.     struct ib_mad        *mad;
  390. };
  391.  
  392. /**
  393.  * ib_mad_recv_wc - received MAD information.
  394.  * @wc: Completion information for the received data.
  395.  * @recv_buf: Specifies the location of the received data buffer(s).
  396.  * @rmpp_list: Specifies a list of RMPP reassembled received MAD buffers.
  397.  * @mad_len: The length of the received MAD, without duplicated headers.
  398.  *
  399.  * For received response, the wr_id contains a pointer to the ib_mad_send_buf
  400.  *   for the corresponding send request.
  401.  */
  402. struct ib_mad_recv_wc {
  403.     struct ib_wc        *wc;
  404.     struct ib_mad_recv_buf    recv_buf;
  405.     struct list_head    rmpp_list;
  406.     int            mad_len;
  407. };
  408.  
  409. /**
  410.  * ib_mad_reg_req - MAD registration request
  411.  * @mgmt_class: Indicates which management class of MADs should be receive
  412.  *   by the caller.  This field is only required if the user wishes to
  413.  *   receive unsolicited MADs, otherwise it should be 0.
  414.  * @mgmt_class_version: Indicates which version of MADs for the given
  415.  *   management class to receive.
  416.  * @oui: Indicates IEEE OUI when mgmt_class is a vendor class
  417.  *   in the range from 0x30 to 0x4f. Otherwise not used.
  418.  * @method_mask: The caller will receive unsolicited MADs for any method
  419.  *   where @method_mask = 1.
  420.  */
  421. struct ib_mad_reg_req {
  422.     u8    mgmt_class;
  423.     u8    mgmt_class_version;
  424.     u8    oui[3];
  425.     DECLARE_BITMAP(method_mask, IB_MGMT_MAX_METHODS);
  426. };
  427.  
  428. /**
  429.  * ib_register_mad_agent - Register to send/receive MADs.
  430.  * @device: The device to register with.
  431.  * @port_num: The port on the specified device to use.
  432.  * @qp_type: Specifies which QP to access.  Must be either
  433.  *   IB_QPT_SMI or IB_QPT_GSI.
  434.  * @mad_reg_req: Specifies which unsolicited MADs should be received
  435.  *   by the caller.  This parameter may be NULL if the caller only
  436.  *   wishes to receive solicited responses.
  437.  * @rmpp_version: If set, indicates that the client will send
  438.  *   and receive MADs that contain the RMPP header for the given version.
  439.  *   If set to 0, indicates that RMPP is not used by this client.
  440.  * @send_handler: The completion callback routine invoked after a send
  441.  *   request has completed.
  442.  * @recv_handler: The completion callback routine invoked for a received
  443.  *   MAD.
  444.  * @context: User specified context associated with the registration.
  445.  */
  446. struct ib_mad_agent *ib_register_mad_agent(struct ib_device *device,
  447.                        u8 port_num,
  448.                        enum ib_qp_type qp_type,
  449.                        struct ib_mad_reg_req *mad_reg_req,
  450.                        u8 rmpp_version,
  451.                        ib_mad_send_handler send_handler,
  452.                        ib_mad_recv_handler recv_handler,
  453.                        void *context);
  454.  
  455. enum ib_mad_snoop_flags {
  456.     /*IB_MAD_SNOOP_POSTED_SENDS       = 1,*/
  457.     /*IB_MAD_SNOOP_RMPP_SENDS       = (1<<1),*/
  458.     IB_MAD_SNOOP_SEND_COMPLETIONS       = (1<<2),
  459.     /*IB_MAD_SNOOP_RMPP_SEND_COMPLETIONS = (1<<3),*/
  460.     IB_MAD_SNOOP_RECVS           = (1<<4)
  461.     /*IB_MAD_SNOOP_RMPP_RECVS       = (1<<5),*/
  462.     /*IB_MAD_SNOOP_REDIRECTED_QPS       = (1<<6)*/
  463. };
  464.  
  465. /**
  466.  * ib_register_mad_snoop - Register to snoop sent and received MADs.
  467.  * @device: The device to register with.
  468.  * @port_num: The port on the specified device to use.
  469.  * @qp_type: Specifies which QP traffic to snoop.  Must be either
  470.  *   IB_QPT_SMI or IB_QPT_GSI.
  471.  * @mad_snoop_flags: Specifies information where snooping occurs.
  472.  * @send_handler: The callback routine invoked for a snooped send.
  473.  * @recv_handler: The callback routine invoked for a snooped receive.
  474.  * @context: User specified context associated with the registration.
  475.  */
  476. struct ib_mad_agent *ib_register_mad_snoop(struct ib_device *device,
  477.                        u8 port_num,
  478.                        enum ib_qp_type qp_type,
  479.                        int mad_snoop_flags,
  480.                        ib_mad_snoop_handler snoop_handler,
  481.                        ib_mad_recv_handler recv_handler,
  482.                        void *context);
  483.  
  484. /**
  485.  * ib_unregister_mad_agent - Unregisters a client from using MAD services.
  486.  * @mad_agent: Corresponding MAD registration request to deregister.
  487.  *
  488.  * After invoking this routine, MAD services are no longer usable by the
  489.  * client on the associated QP.
  490.  */
  491. int ib_unregister_mad_agent(struct ib_mad_agent *mad_agent);
  492.  
  493. /**
  494.  * ib_post_send_mad - Posts MAD(s) to the send queue of the QP associated
  495.  *   with the registered client.
  496.  * @send_buf: Specifies the information needed to send the MAD(s).
  497.  * @bad_send_buf: Specifies the MAD on which an error was encountered.  This
  498.  *   parameter is optional if only a single MAD is posted.
  499.  *
  500.  * Sent MADs are not guaranteed to complete in the order that they were posted.
  501.  *
  502.  * If the MAD requires RMPP, the data buffer should contain a single copy
  503.  * of the common MAD, RMPP, and class specific headers, followed by the class
  504.  * defined data.  If the class defined data would not divide evenly into
  505.  * RMPP segments, then space must be allocated at the end of the referenced
  506.  * buffer for any required padding.  To indicate the amount of class defined
  507.  * data being transferred, the paylen_newwin field in the RMPP header should
  508.  * be set to the size of the class specific header plus the amount of class
  509.  * defined data being transferred.  The paylen_newwin field should be
  510.  * specified in network-byte order.
  511.  */
  512. int ib_post_send_mad(struct ib_mad_send_buf *send_buf,
  513.              struct ib_mad_send_buf **bad_send_buf);
  514.  
  515.  
  516. /**
  517.  * ib_free_recv_mad - Returns data buffers used to receive a MAD.
  518.  * @mad_recv_wc: Work completion information for a received MAD.
  519.  *
  520.  * Clients receiving MADs through their ib_mad_recv_handler must call this
  521.  * routine to return the work completion buffers to the access layer.
  522.  */
  523. void ib_free_recv_mad(struct ib_mad_recv_wc *mad_recv_wc);
  524.  
  525. /**
  526.  * ib_cancel_mad - Cancels an outstanding send MAD operation.
  527.  * @mad_agent: Specifies the registration associated with sent MAD.
  528.  * @send_buf: Indicates the MAD to cancel.
  529.  *
  530.  * MADs will be returned to the user through the corresponding
  531.  * ib_mad_send_handler.
  532.  */
  533. void ib_cancel_mad(struct ib_mad_agent *mad_agent,
  534.            struct ib_mad_send_buf *send_buf);
  535.  
  536. /**
  537.  * ib_modify_mad - Modifies an outstanding send MAD operation.
  538.  * @mad_agent: Specifies the registration associated with sent MAD.
  539.  * @send_buf: Indicates the MAD to modify.
  540.  * @timeout_ms: New timeout value for sent MAD.
  541.  *
  542.  * This call will reset the timeout value for a sent MAD to the specified
  543.  * value.
  544.  */
  545. int ib_modify_mad(struct ib_mad_agent *mad_agent,
  546.           struct ib_mad_send_buf *send_buf, u32 timeout_ms);
  547.  
  548. /**
  549.  * ib_redirect_mad_qp - Registers a QP for MAD services.
  550.  * @qp: Reference to a QP that requires MAD services.
  551.  * @rmpp_version: If set, indicates that the client will send
  552.  *   and receive MADs that contain the RMPP header for the given version.
  553.  *   If set to 0, indicates that RMPP is not used by this client.
  554.  * @send_handler: The completion callback routine invoked after a send
  555.  *   request has completed.
  556.  * @recv_handler: The completion callback routine invoked for a received
  557.  *   MAD.
  558.  * @context: User specified context associated with the registration.
  559.  *
  560.  * Use of this call allows clients to use MAD services, such as RMPP,
  561.  * on user-owned QPs.  After calling this routine, users may send
  562.  * MADs on the specified QP by calling ib_mad_post_send.
  563.  */
  564. struct ib_mad_agent *ib_redirect_mad_qp(struct ib_qp *qp,
  565.                     u8 rmpp_version,
  566.                     ib_mad_send_handler send_handler,
  567.                     ib_mad_recv_handler recv_handler,
  568.                     void *context);
  569.  
  570. /**
  571.  * ib_process_mad_wc - Processes a work completion associated with a
  572.  *   MAD sent or received on a redirected QP.
  573.  * @mad_agent: Specifies the registered MAD service using the redirected QP.
  574.  * @wc: References a work completion associated with a sent or received
  575.  *   MAD segment.
  576.  *
  577.  * This routine is used to complete or continue processing on a MAD request.
  578.  * If the work completion is associated with a send operation, calling
  579.  * this routine is required to continue an RMPP transfer or to wait for a
  580.  * corresponding response, if it is a request.  If the work completion is
  581.  * associated with a receive operation, calling this routine is required to
  582.  * process an inbound or outbound RMPP transfer, or to match a response MAD
  583.  * with its corresponding request.
  584.  */
  585. int ib_process_mad_wc(struct ib_mad_agent *mad_agent,
  586.               struct ib_wc *wc);
  587.  
  588. /**
  589.  * ib_create_send_mad - Allocate and initialize a data buffer and work request
  590.  *   for sending a MAD.
  591.  * @mad_agent: Specifies the registered MAD service to associate with the MAD.
  592.  * @remote_qpn: Specifies the QPN of the receiving node.
  593.  * @pkey_index: Specifies which PKey the MAD will be sent using.  This field
  594.  *   is valid only if the remote_qpn is QP 1.
  595.  * @rmpp_active: Indicates if the send will enable RMPP.
  596.  * @hdr_len: Indicates the size of the data header of the MAD.  This length
  597.  *   should include the common MAD header, RMPP header, plus any class
  598.  *   specific header.
  599.  * @data_len: Indicates the size of any user-transferred data.  The call will
  600.  *   automatically adjust the allocated buffer size to account for any
  601.  *   additional padding that may be necessary.
  602.  * @gfp_mask: GFP mask used for the memory allocation.
  603.  *
  604.  * This routine allocates a MAD for sending.  The returned MAD send buffer
  605.  * will reference a data buffer usable for sending a MAD, along
  606.  * with an initialized work request structure.  Users may modify the returned
  607.  * MAD data buffer before posting the send.
  608.  *
  609.  * The returned MAD header, class specific headers, and any padding will be
  610.  * cleared.  Users are responsible for initializing the common MAD header,
  611.  * any class specific header, and MAD data area.
  612.  * If @rmpp_active is set, the RMPP header will be initialized for sending.
  613.  */
  614. struct ib_mad_send_buf *ib_create_send_mad(struct ib_mad_agent *mad_agent,
  615.                        u32 remote_qpn, u16 pkey_index,
  616.                        int rmpp_active,
  617.                        int hdr_len, int data_len,
  618.                        gfp_t gfp_mask);
  619.  
  620. /**
  621.  * ib_is_mad_class_rmpp - returns whether given management class
  622.  * supports RMPP.
  623.  * @mgmt_class: management class
  624.  *
  625.  * This routine returns whether the management class supports RMPP.
  626.  */
  627. int ib_is_mad_class_rmpp(u8 mgmt_class);
  628.  
  629. /**
  630.  * ib_get_mad_data_offset - returns the data offset for a given
  631.  * management class.
  632.  * @mgmt_class: management class
  633.  *
  634.  * This routine returns the data offset in the MAD for the management
  635.  * class requested.
  636.  */
  637. int ib_get_mad_data_offset(u8 mgmt_class);
  638.  
  639. /**
  640.  * ib_get_rmpp_segment - returns the data buffer for a given RMPP segment.
  641.  * @send_buf: Previously allocated send data buffer.
  642.  * @seg_num: number of segment to return
  643.  *
  644.  * This routine returns a pointer to the data buffer of an RMPP MAD.
  645.  * Users must provide synchronization to @send_buf around this call.
  646.  */
  647. void *ib_get_rmpp_segment(struct ib_mad_send_buf *send_buf, int seg_num);
  648.  
  649. /**
  650.  * ib_free_send_mad - Returns data buffers used to send a MAD.
  651.  * @send_buf: Previously allocated send data buffer.
  652.  */
  653. void ib_free_send_mad(struct ib_mad_send_buf *send_buf);
  654.  
  655. #endif /* IB_MAD_H */
  656.